# Bot check

# HW_ID: fpmi_ad2
# Бот проверит этот ID и предупредит, если случайно сдать что-то не то

# Status: final
# Перед отправкой в финальном решении удали "not" в строчке выше
# Так бот проверит, что ты отправляешь финальную версию, а не промежуточную

from itertools import count

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

sns.set(style='whitegrid', palette='Set2')

# #include <iostream>
# #include <vector>
# #include <cstdlib>
# #include <ctime>
# 
# #define 😃 int
# #define 🎉 void
# #define 🍎 std::vector<int>
# #define 🖨️ std::cout
# #define 🔢 rand()
# #define ⏰ time(0)
# #define 🔀 srand
# #define 🔁 for
# #define 🔄 while
# #define 🎲 if
# #define 🎈 else
# #define 🚀 return
# #define 🎯 main
# #define 🖥️ std::endl
# 
# 🎉 🎭(🍎& 🍏, 😃 🍌, 😃 🍍, 😃 🍇) {
#     😃 🍒 = 🍍 - 🍌 + 1;
#     😃 🍓 = 🍇 - 🍍;
# 
#     🍎 🍑(🍒), 🍐(🍓);
# 
#     🔁 (😃 🍔 = 0; 🍔 < 🍒; 🍔++)
#         🍑[🍔] = 🍏[🍌 + 🍔];
#     🔁 (😃 🍔 = 0; 🍔 < 🍓; 🍔++)
#         🍐[🍔] = 🍏[🍍 + 1 + 🍔];
# 
#     😃 🍔 = 0, 🍕 = 0, 🍖 = 🍌;
#     🔄 (🍔 < 🍒 && 🍕 < 🍓) {
#         🎲 (🍑[🍔] <= 🍐[🍕]) {
#             🍏[🍖] = 🍑[🍔];
#             🍔++;
#         } 🎈 {
#             🍏[🍖] = 🍐[🍕];
#             🍕++;
#         }
#         🍖++;
#     }
# 
#     🔄 (🍔 < 🍒) {
#         🍏[🍖] = 🍑[🍔];
#         🍔++;
#         🍖++;
#     }
# 
#     🔄 (🍕 < 🍓) {
#         🍏[🍖] = 🍐[🍕];
#         🍕++;
#         🍖++;
#     }
# }
# 
# 🎉 🍿(🍎& 🍏, 😃 🍌, 😃 🍇) {
#     🎲 (🍌 < 🍇) {
#         😃 🍍 = 🍌 + (🍇 - 🍌) / 2;
# 
#         🍿(🍏, 🍌, 🍍);
#         🍿(🍏, 🍍 + 1, 🍇);
# 
#         🎭(🍏, 🍌, 🍍, 🍇);
#     }
# }
# 
# 🍎 🎲(😃 🎯, 😃 🎰, 😃 🎳) {
#     🍎 🎨(🎯);
#     🔁 (😃 🍔 = 0; 🍔 < 🎯; 🍔++) {
#         🎨[🍔] = 🔢 % (🎳 - 🎰 + 1) + 🎰;
#     }
#     🚀 🎨;
# }
# 
# 🎉 🖨️(const 🍎& 🍏) {
#     🔁 (😃 🍔 : 🍏) {
#         🖨️ << 🍔 << " ";
#     }
#     🖨️ << 🖥️;
# }
# 
# 😃 🎯() {
#     🔀(⏰);
# 
#     😃 🎯 = 20;
#     😃 🎰 = 0;
#     😃 🎳 = 100;
# 
#     🍎 🍏 = 🎲(🎯, 🎰, 🎳);
# 
#     🖨️ << "?: ";
#     🖨️(🍏);
# 
#     🍿(🍏, 0, 🍏.size() - 1);
# 
#     🖨️ << "??: ";
#     🖨️(🍏);
# 
#     🚀 0;
# }

import random
import time


def merge(arr, left, mid, right):
    """
    Сливает две отсортированные части массива arr:
      - arr[left..mid]
      - arr[mid+1..right]
    Результат сохраняется в arr[left..right].
    """
    n1 = mid - left + 1
    n2 = right - mid

    # Создаем временные массивы для левой и правой половин
    L = arr[left:left + n1]
    R = arr[mid + 1:mid + 1 + n2]

    i, j = 0, 0  # индексы для L и R
    k = left  # индекс для arr

    # Сливаем, пока не достигнем конца одного из подмассивов
    while i < n1 and j < n2:
        if L[i] <= R[j]:
            arr[k] = L[i]
            i += 1
        else:
            arr[k] = R[j]
            j += 1
        k += 1

    # Копируем оставшиеся элементы из L, если они есть
    while i < n1:
        arr[k] = L[i]
        i += 1
        k += 1

    # Копируем оставшиеся элементы из R, если они есть
    while j < n2:
        arr[k] = R[j]
        j += 1
        k += 1


def merge_sort(arr, left, right):
    """
    Рекурсивная сортировка слиянием.
    Сортирует часть массива arr с индексами от left до right.
    """
    if left < right:
        mid = (left + right) // 2
        merge_sort(arr, left, mid)
        merge_sort(arr, mid + 1, right)
        merge(arr, left, mid, right)


def generate_random_vector(size, low, high):
    """
    Генерирует список из size случайных целых чисел
    в диапазоне [low, high].
    """
    return [random.randint(low, high) for _ in range(size)]


def print_vector(arr):
    """
    Выводит элементы списка arr в одну строку.
    """
    print(" ".join(map(str, arr)))


def main():
    # Инициализируем генератор случайных чисел
    random.seed(time.time())

    n = 20  # размер массива
    low = 0  # нижняя граница случайных чисел
    high = 100  # верхняя граница случайных чисел

    arr = generate_random_vector(n, low, high)

    print("?: ", end="")
    print_vector(arr)

    merge_sort(arr, 0, len(arr) - 1)

    print("??: ", end="")
    print_vector(arr)


if __name__ == "__main__":
    main()

?: 84 26 62 25 79 11 53 99 91 52 33 81 56 41 40 12 10 73 8 82
??: 8 10 11 12 25 26 33 40 41 52 53 56 62 73 79 81 82 84 91 99

import plotly.graph_objects as go


def plot_3d_surface():
    x = np.linspace(-10, 10, 200)
    y = np.linspace(-10, 10, 200)
    x, y = np.meshgrid(x, y)
    z = np.cos(np.sqrt(x ** 2 + y ** 2))

    fig = go.Figure(data=[go.Surface(z=z, x=x, y=y)])
    fig.update_layout(
        title='Cosine Function 3D Surface Plot',
        scene=dict(
            xaxis_title='X Axis',
            yaxis_title='Y Axis',
            zaxis_title='Z Axis',
            aspectmode='cube',
        ),
        margin=dict(l=0, r=0, b=0, t=0)
    )

    fig.show()


plot_3d_surface()

import numpy as np
import plotly.graph_objects as go


def plot_3d_surface(**kwargs):
    """
    Строит 3D-график поверхности функции z = cos(sqrt(x^2 + y^2)) с помощью Plotly.

    Параметры:
    ----------
    **kwargs : dict
        Словарь произвольных именованных аргументов, которые позволяют
        настраивать как сами данные для графика, так и параметры макета (layout).
        
        Ниже несколько примеров ключей и их значений:
        
        - surface_params : dict
            Дополнительные параметры для go.Surface (например, colorscale, opacity и т.д.).
            Пример: surface_params={'colorscale': 'Viridis', 'showscale': False}
            
        - layout_params : dict
            Дополнительные параметры для layout (например, ширина/высота, фоновый цвет и т.д.).
            Пример: layout_params={'width': 700, 'height': 700}
            
        - title : str
            Заголовок графика (по умолчанию 'Cosine Function 3D Surface Plot').
            
        - scene : dict
            Настройки 3D-сцены (ось X, Y, Z, режим отображения и т.д.).
            Пример: scene={'xaxis_title': 'My X', 'yaxis_title': 'My Y', 'zaxis_title': 'My Z'}
            
        - margin : dict
            Отступы от краёв фигуры. По умолчанию равны 0.
            Пример: margin={'l': 10, 'r': 10, 'b': 20, 't': 40}
    
    Пример вызова:
    -------------
    plot_3d_surface(
        title="Мой 3D-график",
        surface_params={'colorscale': [[0, 'pink'], [1, 'lightblue']]},
        scene={'xaxis_title': 'X', 'yaxis_title': 'Y', 'zaxis_title': 'Z'},
        margin={'l': 0, 'r': 0, 'b': 0, 't': 50},
        layout_params={'width': 800, 'height': 800}
    )
    
    Результат:
    ----------
    Отрисовывает интерактивный 3D-график, который автоматически открывается в браузере
    или внутри Jupyter Notebook, в зависимости от среды выполнения.
    """

    # 1) Генерируем координаты x и y в диапазоне [-10, 10] с 200 точками в каждом направлении
    x_vals = np.linspace(-10, 10, 200)
    y_vals = np.linspace(-10, 10, 200)

    # 2) Создаем сетку из x_vals и y_vals
    #   meshgrid(x, y) возвращает двумерные массивы X и Y, где:
    #   - X[i, j] = x[j] (по столбцам)
    #   - Y[i, j] = y[i] (по строкам)
    #   Это нужно, чтобы можно было рассчитать Z для каждой точки (x, y).
    x, y = np.meshgrid(x_vals, y_vals)

    # 3) Вычисляем z = cos( sqrt(x^2 + y^2) )
    #   sqrt(x^2 + y^2) — это радиальное расстояние от начала координат в 2D.
    z = np.cos(np.sqrt(x ** 2 + y ** 2))

    # Извлекаем пользовательские настройки из kwargs или подставляем значения по умолчанию
    surface_params = kwargs.get('surface_params', {})
    layout_params = kwargs.get('layout_params', {})
    title = kwargs.get('title', 'Cosine Function 3D Surface Plot')
    scene = kwargs.get('scene', dict(
        xaxis_title='X Axis',
        yaxis_title='Y Axis',
        zaxis_title='Z Axis',
        aspectmode='cube',
    ))
    margin = kwargs.get('margin', dict(l=0, r=0, b=0, t=0))

    # 4) Создаем фигуру (Figure) с одним объектом Surface
    #   go.Figure(...) — это базовый объект графика в Plotly, содержащий набор данных (data) и макет (layout).
    #   go.Surface(...) — это 3D-поверхность, построенная по массивам x, y, z.
    #   'colorscale' — параметр, который отвечает за цветовую палитру.
    #   Ниже установлен кастомный градиент от светло-розового к светло-голубому,
    #   если пользователь не передал свою палитру в surface_params.
    default_colorscale = [[0, 'rgb(255, 182, 193)'],  # светло-розовый
                          [1, 'rgb(173, 216, 230)']]  # светло-голубой
    if 'colorscale' not in surface_params:
        surface_params['colorscale'] = default_colorscale

    fig = go.Figure(
        data=[
            go.Surface(
                x=x,  # Координаты X
                y=y,  # Координаты Y
                z=z,  # Координаты Z (высота)
                **surface_params  # Применяем все параметры, которые передал пользователь
            )
        ]
    )

    # 5) Настраиваем макет (layout) с помощью update_layout
    #   update_layout позволяет изменить заголовок, размеры, отступы, оси и т.д.
    #   scene — словарь, содержащий настройки 3D-сцены (названия осей, режимы отображения).
    #   margin — отступы от краёв графика.
    fig.update_layout(
        title=title,
        scene=scene,
        margin=margin,
        **layout_params  # Применяем все дополнительные параметры для layout, переданные пользователем
    )

    # 6) Показываем итоговый график
    fig.show()


# ------------------------------------------------------------------------------
# Ниже — краткие описания упомянутых функций и опций
# ------------------------------------------------------------------------------

"""
1) np.meshgrid(x, y)
   Функция из библиотеки NumPy, которая принимает одномерные массивы x и y
   и возвращает двумерные массивы X и Y. 
   X и Y можно рассматривать как координатную сетку, 
   где X[i,j] соответствует координате x, а Y[i,j] — координате y.

2) go.Figure
   Класс из plotly.graph_objects. Создает объект «фигуры», 
   в котором хранятся данные (data) и макет (layout) графика.

3) go.Surface
   Класс, описывающий 3D-поверхность в Plotly. 
   Принимает массивы x, y, z, а также другие параметры (colorscale, opacity и т.д.). 
   Используется для отображения 3D-поверхностей.

4) update_layout
   Метод объекта Figure, который позволяет обновлять параметры макета (layout):
   заголовки, легенды, размеры, шрифты, цвета фона, отступы и многое другое.

5) scene
   Ключ в layout, отвечающий за 3D-сцену. В нем можно настраивать:
   - xaxis_title, yaxis_title, zaxis_title — подписи к осям
   - aspectmode (например, 'cube') — режим пропорций осей 
   - другие параметры (цвет осей, сетку и т.д.)

6) margin
   Ключ в layout, отвечающий за отступы графика (слева, справа, сверху, снизу).
   margin=dict(l=0, r=0, t=0, b=0) означает, что у графика нет отступов.
"""

# ------------------------------------------------------------------------------
# Пример использования функции plot_3d_surface
# ------------------------------------------------------------------------------
plot_3d_surface(
    title="Моя косинусная поверхность",
    surface_params={
        'colorscale': [[0, 'yellow'], [1, 'lightblue']],  # свой градиент
        'showscale': True,  # показать цветовую шкалу
    },
    scene={
        'xaxis_title': 'X',
        'yaxis_title': 'Y',
        'zaxis_title': 'Z',
        'aspectmode': 'cube'
    },
    margin={'l': 10, 'r': 10, 'b': 10, 't': 30},
    layout_params={
        'width': 800,
        'height': 800
    }
)

colorscale = [[0, 'rgb(255,182,193)'],  # светло-розовый
              [1, 'rgb(173,216,230)']]  # светло-голубой

import numpy as np
import plotly.graph_objects as go


def plot_3d_surface():
    # Создаем массивы координат x и y в диапазоне от -10 до 10 с 200 точками
    x_vals = np.linspace(-10, 10, 200)
    y_vals = np.linspace(-10, 10, 200)
    x, y = np.meshgrid(x_vals, y_vals)

    # Вычисляем z = cos(sqrt(x^2 + y^2))
    z = np.cos(np.sqrt(x ** 2 + y ** 2))

    # Задаем colorscale от светло-розового до светло-голубого
    custom_colorscale = [[0, 'rgb(255,182,193)'],  # светло-розовый
                         [1, 'rgb(173,216,230)']]  # светло-голубой

    # Создаем 3D-фигура с поверхностью и устанавливаем colorscale
    fig = go.Figure(data=[go.Surface(z=z, x=x, y=y, colorscale=custom_colorscale)])

    # Обновляем макет графика
    fig.update_layout(
        title='Cosine Function 3D Surface Plot',
        scene=dict(
            xaxis_title='X Axis',
            yaxis_title='Y Axis',
            zaxis_title='Z Axis',
            aspectmode='cube',
        ),
        margin=dict(l=0, r=0, b=0, t=0)
    )

    # Отображаем график
    fig.show()


plot_3d_surface()

import numpy as np
import plotly.graph_objects as go


def plot_3d_surface(**kwargs):
    """
    Строит интерактивный 3D-график поверхности функции z = cos(sqrt(x^2 + y^2)) с помощью Plotly.

    Параметры:
    ----------
    **kwargs : dict
        Дополнительные именованные параметры для настройки графика. Возможные ключи:
        
        - surface_params : dict
            Словарь параметров для объекта go.Surface.
            Например:
                {'colorscale': [[0, 'pink'], [1, 'lightblue']], 'showscale': True}
            Если не указан, используется градиент от светло-розового до светло-голубого.
            
        - layout_params : dict
            Словарь дополнительных параметров для макета графика (layout).
            Например:
                {'width': 800, 'height': 800}
                
        - title : str
            Заголовок графика. По умолчанию: "Cosine Function 3D Surface Plot".
            
        - scene : dict
            Словарь параметров 3D-сцены, задающих подписи осей и режим отображения.
            Например:
                {'xaxis_title': 'X Axis', 'yaxis_title': 'Y Axis', 'zaxis_title': 'Z Axis', 'aspectmode': 'cube'}
                
        - margin : dict
            Словарь отступов графика от краёв контейнера.
            Например:
                {'l': 10, 'r': 10, 'b': 10, 't': 50}

    Пример использования:
    ---------------------
    plot_3d_surface(
        title="Мой 3D-график косинуса",
        surface_params={'colorscale': [[0, 'pink'], [1, 'lightblue']], 'showscale': True},
        scene={'xaxis_title': 'X', 'yaxis_title': 'Y', 'zaxis_title': 'Z', 'aspectmode': 'cube'},
        margin={'l': 10, 'r': 10, 'b': 10, 't': 50},
        layout_params={'width': 800, 'height': 800}
    )

    Результат:
    ---------
    Функция создаёт и отображает интерактивный 3D-график, который можно вращать, масштабировать и исследовать.
    """

    # Генерируем одномерные массивы значений для осей x и y
    x_vals = np.linspace(-10, 10, 200)
    y_vals = np.linspace(-10, 10, 200)

    # Функция np.meshgrid создает двумерную сетку координат из x_vals и y_vals.
    # x и y — двумерные массивы, содержащие координаты точек на плоскости.
    x, y = np.meshgrid(x_vals, y_vals)

    # Вычисляем значение функции z = cos(sqrt(x^2 + y^2))
    z = np.cos(np.sqrt(x ** 2 + y ** 2))

    # Значения по умолчанию для параметров
    default_surface_params = {
        'colorscale': [[0, 'rgb(255,182,193)'], [1, 'rgb(173,216,230)']]}  # от светло-розового к светло-голубому
    default_layout_params = {}
    default_title = 'Cosine Function 3D Surface Plot'
    default_scene = {
        'xaxis_title': 'X Axis',
        'yaxis_title': 'Y Axis',
        'zaxis_title': 'Z Axis',
        'aspectmode': 'cube'
    }
    default_margin = {'l': 0, 'r': 0, 'b': 0, 't': 0}

    # Извлекаем параметры из kwargs, если они заданы пользователем, иначе используем значения по умолчанию
    surface_params = kwargs.get('surface_params', default_surface_params)
    layout_params = kwargs.get('layout_params', default_layout_params)
    title = kwargs.get('title', default_title)
    scene = kwargs.get('scene', default_scene)
    margin = kwargs.get('margin', default_margin)

    # Создаем фигуру (Figure) с объектом Surface.
    # go.Surface отвечает за построение 3D-поверхности, а параметр colorscale задает цветовую палитру.
    fig = go.Figure(
        data=[go.Surface(x=x, y=y, z=z, **surface_params)]
    )

    # update_layout настраивает макет (layout) графика: заголовок, отступы, настройки 3D-сцены и другие параметры.
    fig.update_layout(
        title=title,
        scene=scene,
        margin=margin,
        **layout_params
    )

    # Отображаем график
    fig.show()


# Пример использования функции с настройками через kwargs
if __name__ == '__main__':
    plot_3d_surface(
        title="Мой кастомный 3D-график",
        surface_params={'colorscale': [[0, 'pink'], [1, 'lightblue']], 'showscale': True},
        scene={'xaxis_title': 'Ось X', 'yaxis_title': 'Ось Y', 'zaxis_title': 'Ось Z', 'aspectmode': 'cube'},
        margin={'l': 10, 'r': 10, 'b': 10, 't': 50},
        layout_params={'width': 800, 'height': 800}
    )

business = pd.read_csv('yelp_data/yelp_business.csv')

grouped = business.groupby(["city"]).count()
grouped.sort_values(by='business_id', ascending=False, inplace=True)
top_cities = list(grouped.head().index)
top_cities

['Las Vegas', 'Phoenix', 'Toronto', 'Charlotte', 'Scottsdale']

top_city_businesses = business[business.city == top_cities[0]]
# К этому моменту мы еще не использовали датасет с оценками.
import folium

m = folium.Map(location=[top_city_businesses['latitude'].mean(),
                         top_city_businesses['longitude'].mean()],
               zoom_start=10)

for idx, row in top_city_businesses.iterrows():
    if idx % 5 == 0:
        folium.CircleMarker(
            location=[row['latitude'], row['longitude']],
            radius=4,
            color='blue',
            fill=True,
            fill_color='blue',
            fill_opacity=0.5,
        ).add_to(m)

m.save('my_map.html');

import math


def haversine_distance(lat1, lon1, lat2=top_city_businesses['latitude'].mean(),
                       lon2=top_city_businesses['longitude'].mean()):
    """
    Вычисляет расстояние между двумя точками на поверхности Земли,
    заданными широтой и долготой, используя формулу гаверсинусов.

    Параметры:
        lat1, lon1: широта и долгота первой точки (в градусах)
        lat2, lon2: широта и долгота второй точки (в градусах)

    Возвращает:
        Расстояние между точками в километрах.
    """
    lat1, lon1, lat2, lon2 = map(math.radians, [lat1, lon1, lat2, lon2])

    dlat = lat2 - lat1
    dlon = lon2 - lon1

    a = math.sin(dlat / 2) ** 2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon / 2) ** 2
    c = 2 * math.asin(math.sqrt(a))

    R = 6371
    return R * c


top_city_businesses = top_city_businesses.copy()

top_city_businesses['dist'] = top_city_businesses.apply(
    lambda row: haversine_distance(row['latitude'], row['longitude']),
    axis=1
)

quantile = top_city_businesses['dist'].quantile(0.95)

top_city_businesses = top_city_businesses[top_city_businesses['dist'] <= quantile];

# блин, я до этого и так построил интерактивную карту, не дочитав до конца.

m = folium.Map(location=[top_city_businesses['latitude'].mean(), top_city_businesses['longitude'].mean()],
               zoom_start=10)

for idx, row in top_city_businesses.iterrows():
    if idx % 5 == 0:
        folium.CircleMarker(
            location=[row['latitude'], row['longitude']],
            radius=4,
            color='blue',
            fill=True,
            fill_color='blue',
            fill_opacity=0.5
        ).add_to(m)

m.save('my_map2.html')

reviews = pd.read_csv("yelp_data/yelp_review.csv");

reviews_indexed = reviews.set_index('business_id')
best_city_reviews = reviews_indexed.loc[reviews_indexed.index.isin(top_city_businesses['business_id'])]

best_city_reviews = best_city_reviews.reset_index()

companies_average_stars = best_city_reviews.groupby('business_id').aggregate(['mean', 'size'])

companies_average_stars.columns = pd.MultiIndex.from_tuples(
    [('business_id', 'mean'), ('business_id', 'size'),
     ('stars', 'mean'), ('stars', 'size')],
    names=['business_id', 'statistic']
)

companies_average_stars.columns = companies_average_stars.columns.set_levels(
    ['avg rating', 'num_reviews'], level=1
)
# companies_average_stars.drop(columns=['Unnamed: 0 mean', 'Unnamed: 0 size'], inplace=True)
companies_average_stars = companies_average_stars.drop(columns=[('business_id', 'avg rating'), ('business_id', 'num_reviews')])
companies_average_stars.columns = ['_'.join(x).replace(' ', '_') for x in companies_average_stars.columns]

companies_average_stars.columns = ['avg_rating', 'reviews_count']

best_city_reviews_expanded = pd.merge(top_city_businesses, companies_average_stars, on='business_id')
best_city_reviews_expanded.drop(
    columns=['Unnamed: 0', 'neighborhood', 'address', 'postal_code', 'is_open'],
    inplace=True)

import folium

# Функция преобразования рейтинга в RGB, используя логарифмическую шкалу для плавной градации
def rating_to_rgb(rating):
    """
    Преобразует оценку от 1 до 5 в RGB цвет с улучшенной градацией с использованием логарифмической шкалы.
    1 -> Красный (rgb(255, 0, 0))
    5 -> Зелёный (rgb(0, 255, 0))
    """
    norm_rating = np.log(rating) / np.log(5)  # Логарифмическая нормализация
    cmap = plt.get_cmap('RdYlGn')             # Палитра от красного до зелёного
    norm = Normalize(vmin=0, vmax=1)
    sm = ScalarMappable(cmap=cmap, norm=norm)
    rgba = sm.to_rgba(norm_rating)            # Получаем цвет в формате RGBA
    return f'#{int(rgba[0]*255):02x}{int(rgba[1]*255):02x}{int(rgba[2]*255):02x}'

# Создаём карту с центром, взятым по среднему значению координат компаний
m = folium.Map(location=[top_city_businesses['latitude'].mean(), top_city_businesses['longitude'].mean()],
               zoom_start=10)

# Добавляем маркеры с цветовой градацией и всплывающей подсказкой, показывающей рейтинг
for idx, row in best_city_reviews_expanded.iterrows():
    if idx % 5 == 0:
        folium.CircleMarker(
            location=[row['latitude'], row['longitude']],
            radius=4,
            color=rating_to_rgb(row['avg_rating']),
            fill=True,
            fill_opacity=0.3,
            tooltip=f"Рейтинг: {row['avg_rating']:.2f}"
        ).add_to(m)

# Сохранение карты
m.save('my_map3_enhanced.html')

best_city_reviews_expanded['latitude'] = round(best_city_reviews_expanded['latitude'], 2)
best_city_reviews_expanded['longitude'] = round(best_city_reviews_expanded['longitude'], 2)

import folium
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import Normalize
from matplotlib.cm import ScalarMappable

# Функция преобразования рейтинга в RGB, используя логарифмическую шкалу для плавной градации
def rating_to_rgb(rating):
    """
    Преобразует оценку от 1 до 5 в RGB цвет с улучшенной градацией.
    1 -> Красный (rgb(255, 0, 0))
    5 -> Зелёный (rgb(0, 255, 0))
    """
    norm_rating = np.log(rating) / np.log(5)  # Логарифмическая нормализация
    cmap = plt.get_cmap('RdYlGn')             # Палитра от красного до зелёного
    norm = Normalize(vmin=0, vmax=1)
    sm = ScalarMappable(cmap=cmap, norm=norm)
    rgba = sm.to_rgba(norm_rating)            # Преобразуем в RGBA
    return f'#{int(rgba[0]*255):02x}{int(rgba[1]*255):02x}{int(rgba[2]*255):02x}'

# Создаём карту с центром по средним координатам компаний
m = folium.Map(location=[top_city_businesses['latitude'].mean(), top_city_businesses['longitude'].mean()],
               zoom_start=10)

# Добавляем маркеры с улучшенной градацией и всплывающей подсказкой, показывающей рейтинг
for idx, row in best_city_reviews_expanded.iterrows():
    if idx % 5 == 0:
        folium.CircleMarker(
            location=[row['latitude'], row['longitude']],
            radius=4,
            color=rating_to_rgb(row['avg_rating']),
            fill=True,
            fill_opacity=0.3,
            tooltip=f"Рейтинг: {row['avg_rating']:.2f}"
        ).add_to(m)

# Сохраняем карту
m.save('my_map4_enhanced.html')

pivot = pd.pivot_table(best_city_reviews_expanded, index='latitude', columns='longitude', aggfunc='mean', values='avg_rating')
plt.figure(figsize=(8, 6))
ax = sns.heatmap(
    pivot,
    cmap='RdYlGn',
    vmin=1,
    vmax=5,
    cbar_kws={'label': 'Средняя оценка'},
    linewidths=0.5,
    linecolor='gray'
)
ax.set_title('Средние оценки по районам')
ax.set_xlabel('Долгота')
ax.set_ylabel('Широта')
plt.gca().invert_yaxis();

cmp_cnt = pd.pivot_table(best_city_reviews_expanded, index='latitude', columns='longitude', aggfunc='size')
plt.figure(figsize=(10, 8))
data = pivot.where(cmp_cnt >= 30)
ax = sns.heatmap(
    data,
    cmap='RdYlGn',
    vmin=3,
    vmax=4,
    cbar_kws={'label': 'Средняя оценка'},
    linewidths=0.5,
    linecolor='gray'
)
ax.set_title('Средние оценки по районам (не менее 30 компаний)')
ax.set_xlabel('Долгота')
ax.set_ylabel('Широта')
plt.gca().invert_yaxis()
plt.show();

restaurant_categories = [
    "Restaurant", "restaurant",
    "Restaraunt", "restoraunt",
    "Restorant", "restorant",
    "Cafe", "cafe", "Café", "caf'e",
    "Bistro", "bistro",
    "Eatery", "eatery",
    "Diner", "diner",
    "Fast Food", "fast food",
    "Grill", "grill",
    "Pub", "pub"
]

bitmask = top_city_businesses.apply(lambda row: True if any([cat in row['categories'].lower() for cat in restaurant_categories]) else False,
                                    axis=1)
top_city_restaurant = top_city_businesses[bitmask]

bitmask = top_city_restaurant.apply(lambda row: True if (companies_average_stars.loc[row["business_id"], 'reviews_count'] >= 5) else False,
                                    axis=1)
top_city_restaurant = top_city_restaurant[bitmask]
# top_city_restaurant = top_city_restaurant.merge(best_city_reviews_expanded, how='inner', on='business_id')
# top_city_restaurant
top_city_restaurant["latitude"] = round(top_city_restaurant['latitude'], 2)
top_city_restaurant["longitude"] = round(top_city_restaurant['longitude'], 2)
cmp_cnt = pd.pivot_table(top_city_restaurant, index='latitude', columns='longitude', aggfunc='size')
# cmp_cnt
ax = sns.heatmap(pivot[cmp_cnt >= 10], cmap=plt.get_cmap('RdYlGn'))
ax.set_xlabel('Долгота')
ax.set_ylabel('Широта');

Text(47.25, 0.5, 'Широта')

# top_city_restaurant = top_city_restaurant.merge(companies_average_stars, on='business_id', how='inner')
top_city_restaurant.sort_values(by=['avg_rating', 'reviews_count'], ascending=False, inplace=True)
top_city_restaurant_verified = top_city_restaurant[top_city_restaurant['reviews_count'] >= 50]
top_city_restaurant_verified[['name', 'avg_rating', 'reviews_count', 'latitude', 'longitude', 'categories']].head(10);

import matplotlib.patches as patches

plt.figure(figsize=(12, 8))
pivot = pd.pivot_table(
    top_city_restaurant_verified[top_city_restaurant_verified["avg_rating"] >= 4.7],
    index='latitude',
    columns='longitude',
    aggfunc='mean',
    values='avg_rating'
)
ax = sns.heatmap(pivot, cmap='coolwarm', annot=True, fmt='.2f', linewidths=0.5)

top10 = top_city_restaurant_verified.head(10)
for _, row in top10.iterrows():
    lat = round(row['latitude'], 2)
    lon = round(row['longitude'], 2)
    try:
        lat_idx = pivot.index.get_loc(lat)
        lon_idx = pivot.columns.get_loc(lon)
        # Выделяем ячейку рамкой, чтобы не перекрывать данные
        rect = patches.Rectangle(
            (lon_idx, lat_idx), 1, 1,
            fill=False, edgecolor='lime', lw=3, linestyle='--'
        )
        ax.add_patch(rect)
    except KeyError:
        continue

plt.title('Рестораны с оценкой не менее 4.7')
plt.xlabel('Долгота')
plt.ylabel('Широта')
plt.gca().invert_yaxis()
plt.show()

Введение в анализ данных ¶

Домашнее задание 2. Простой анализ данных и ИИ-инструменты.¶

Легкая часть¶

Задача 1.¶

Задача 2.¶

Что делает функция ?¶

Вычисляет значения Z для каждой точки сетки по формуле: 𝑧¶

Что делает функция ?¶

Вычисляет значения Z для каждой точки сетки по формуле: 𝑧¶

Сложная часть¶

Задача 3.¶

1. Город с наибольшим количеством компаний¶

2. Оценки компаний¶

Ответ:¶

3. Рестораны¶

Задача 4.¶

Трансформеры и языковые модели¶

Компьютерное зрение и визуальные модели¶

Self-Supervised and Contrastive Learning¶

Обучение с подкреплением¶

Архитектуры нейросетей и их масштабирование¶

Математика, байесовские методы и причинно-следственный анализ¶

Введение в анализ данных¶

Домашнее задание 2. Простой анализ данных и ИИ-инструменты.¶

Легкая часть¶

Задача 1.¶

Задача 2.¶

Что делает функция ?¶

Вычисляет значения Z для каждой точки сетки по формуле: 𝑧¶

Что делает функция ?¶

Вычисляет значения Z для каждой точки сетки по формуле: 𝑧¶

Сложная часть¶

Задача 3.¶

1. Город с наибольшим количеством компаний¶

2. Оценки компаний¶

Ответ:¶

3. Рестораны¶

Задача 4.¶

Трансформеры и языковые модели¶

Компьютерное зрение и визуальные модели¶

Self-Supervised and Contrastive Learning¶

Обучение с подкреплением¶

Архитектуры нейросетей и их масштабирование¶

Математика, байесовские методы и причинно-следственный анализ¶

Введение в анализ данных ¶